﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace Systemet.Technical
{
    class PrognosConnection
    {
        private LinqToSQLDataContext database;
        //private bool successfull = false;
        private string pass = AccessController.Instance.Connection;

        //Insertar produkter från Produktregister till Uppföljning/Prognos.. Notera!(Anropet till denna metod ligger i PrognosKortView som kommenterad.)Den fungerar dock
        public void InsertProducts(List<Prognos> newPrognoses)
        {
            database = new LinqToSQLDataContext(pass);

            foreach (Prognos p in newPrognoses)
            {
                UppföljningProgno pr = new UppföljningProgno
                {
                    produktID = p.ProduktID,
                    budget = (int)p.Budget,
                    Datum = p.Datum,
                    avserÅr = p.AvserDatum,
                    prognossumma = p.prognos,
                    FöregåendePrognos = p.Föregåendeprognos,
                    låst = p.Låst,
                    Upparbetat = p.Upparbetat,
                    UtfallMånad = p.Utfallmånad,

                };
                database.UppföljningPrognos.InsertOnSubmit(pr);
            }
            database.SubmitChanges();
            database.Connection.Close();

        }
        //Inserta textvärden från txt filen.
        public void InsertText(Prognos prognos)
        {
            try
            {

                database = new LinqToSQLDataContext(pass);
                //Kolla att varje rad på textfilen 
                var Checkprognos = (from Prognos in database.UppföljningPrognos
                                    where prognos.Datum.Month == Prognos.Datum.Month && prognos.ProduktID == Prognos.produktID
                                    select Prognos).Count();

                //Om Checkprognos hittar värden på den månaden och på det produktID
                if (Checkprognos > 0)
                {
                    UppföljningProgno prog = database.UppföljningPrognos.Single(u => u.produktID == prognos.ProduktID && u.Datum.Month == prognos.Datum.Month);
                    {
                        int utfall = 0;
                        if (prognos.Utfallmånad != null)
                        {
                            utfall = (int)prognos.Utfallmånad;
                        }
                        if (prog.UtfallMånad != null)
                        {
                            utfall += (int)prog.UtfallMånad;
                        }

                        prog.UtfallMånad = (int)utfall;
                    };
                    database.SubmitChanges();
                    database.Connection.Close();
                }
                //Skapa en ny post
                else
                {
                    UppföljningProgno p = new UppföljningProgno
                    {
                        produktID = prognos.ProduktID,
                        Datum = prognos.Datum,
                        UtfallMånad = prognos.Utfallmånad,
                        avserÅr = DateTime.Now,
                        låst = false
                    };
                    database.UppföljningPrognos.InsertOnSubmit(p);
                    database.SubmitChanges();
                    database.Connection.Close();
                }

            }
            catch (Exception e)
            {
                database.Connection.Close();
            }

        }

        //Kolla om prognostisering gjorts för en viss månad förhindrar att textfil läses in där igen
        public bool ValidatePrognosedMonth(int month)
        {
            database = new LinqToSQLDataContext(pass);
            var query = from Uppföljningsprognos in database.UppföljningPrognos
                        where Uppföljningsprognos.Datum.Month == month
                        select Uppföljningsprognos;

            if (query.Count() > 0)
            {
                database.Connection.Close();
                return false;
            }
            else
            {
                database.Connection.Close();
                return true;
            }
        }

        //Kollar om prognos blivit låst på en viss månad
        public bool ValidatePrognosesLockedDown(int month)
        {
            if (month == 1)
            {
                month = 2;
            }

            database = new LinqToSQLDataContext(pass);

            var query = from UppföljningProgno in database.UppföljningPrognos
                        where UppföljningProgno.låst == false && UppföljningProgno.Datum.Month == month - 1
                        select UppföljningProgno;

            int antal = query.Count();

            if (antal > 0)
            {
                database.Connection.Close();
                return false;
            }
            else
            {
                database.Connection.Close();
                return true;
            }
        }
        //Lås Prognostiseringsmånad
        public bool LockPrognoses(int month)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var prognosesToUpdate = from UppföljningProgno in database.UppföljningPrognos
                                        where UppföljningProgno.låst == false && UppföljningProgno.Datum.Month == month
                                        select UppföljningProgno;

                foreach (UppföljningProgno Prognos in prognosesToUpdate)
                {
                    Prognos.låst = true;
                }

                database.SubmitChanges();
            }
            catch (Exception e)
            {
                return false;
            }
            finally
            {
                database.Connection.Close();
            }
            database.Connection.Close();
            return true;
        }
        //Validera för låsning hämtar alla prognostiseringsobjekt som inte fått en prognos
        public List<Prognos> CheckForUnPrognosedProducts(int month)
        {
            database = new LinqToSQLDataContext(pass);

            var query = from UppföljningProgno in database.UppföljningPrognos
                        where UppföljningProgno.Datum.Month == month && UppföljningProgno.prognossumma < 0 || UppföljningProgno.prognossumma == null
                        select UppföljningProgno;

            List<Prognos> UnPrognost = query.AsEnumerable()
                .Select(unP => new Prognos
                {
                    ProduktID = unP.produktID,
                    Produkt = unP.Produktregister.produkt
                }).ToList();

            return UnPrognost;
        }



        //Visa alla prognoser
        public List<Prognos> ShowAllPrognos(int month, string avd, string prodkate, string prodgrupp, string prodnamn)
        {
            database = new LinqToSQLDataContext(pass);

            var prognoser = from UppföljningProgno in database.UppföljningPrognos
                            join Produkt in database.Produktregisters on UppföljningProgno.produktID equals Produkt.produktID
                            where UppföljningProgno.Datum.Month == month && UppföljningProgno.Produktregister.avdelningsnamn.Contains(avd)
                            && UppföljningProgno.Produktregister.Produktkategori.produktKategoriNamn.Contains(prodkate) && UppföljningProgno.Produktregister.Produktgrupp.produktGruppNamn.Contains(prodgrupp)
                            && UppföljningProgno.Produktregister.produkt.Contains(prodnamn)
                            select UppföljningProgno;

            List<Prognos> prog = prognoser.AsEnumerable()
                                 .Select(s => new Prognos
                                 {
                                     ProduktID = s.produktID,
                                     Produkt = s.Produktregister.produkt,
                                     Budget = s.budget,
                                     Utfallmånad = s.UtfallMånad,
                                     Datum = s.Datum,
                                     Föregåendeprognos = s.FöregåendePrognos,
                                     Upparbetat = s.Upparbetat,
                                     prognos = s.prognossumma,
                                     Låst = (bool)s.låst


                                 }).ToList();
            return prog.ToList();
        }
        //Hämta alla tidigare gjorda prognoser
        public List<Prognos> RetrieveAllEarlierPrognoses(int month)
        {
            database = new LinqToSQLDataContext(pass);

            var prognoser = from UppföljningProgno in database.UppföljningPrognos
                            join Produkt in database.Produktregisters on UppföljningProgno.produktID equals Produkt.produktID
                            where UppföljningProgno.Datum.Month < month
                            select UppföljningProgno;

            List<Prognos> prog = prognoser.AsEnumerable()
                                 .Select(s => new Prognos
                                 {
                                     ProduktID = s.produktID,
                                     Produkt = s.Produktregister.produkt,
                                     Budget = s.budget,
                                     Utfallmånad = s.UtfallMånad,
                                     Datum = s.Datum,
                                     Föregåendeprognos = s.FöregåendePrognos,
                                     Upparbetat = s.Upparbetat,
                                     prognos = s.prognossumma,
                                     Låst = (bool)s.låst


                                 }).ToList();
            return prog.ToList();
        }


        public List<Produkt> ShowAllProducts()
        {
            database = new LinqToSQLDataContext(pass);

            var prognoser = from Produkt in database.UppföljningPrognos
                            join Prognos in database.Produktregisters on Produkt.produktID equals Prognos.produktID
                            orderby Produkt.Produktregister.produkt ascending
                            select new { Produkt.produktID, Produkt.Produktregister.produkt };

            List<Produkt> Kontolista = prognoser.AsEnumerable()
                                 .Select(s => new Produkt
                                 {
                                     ProduktID = s.produktID,
                                     ProduktNamn = s.produkt,

                                 }).ToList();
            return Kontolista.ToList();
        }



        //Hämta alla intäktsbudgetar för detta året
        public List<Intäktsbudget> GetBudgetsOnThisYear()
        {

            database = new LinqToSQLDataContext(pass);

            var query = from Intäktsbudget in database.Intäktsbudgetregisters
                        join Produkt in database.Produktregisters on Intäktsbudget.produktID equals Produkt.produktID
                        where Intäktsbudget.avserÅr.Value.Year == DateTime.Now.Year
                        group Intäktsbudget by new { Produkt.produktID, Produkt.produkt } into g
                        select new
                        {
                            ProduktID = g.Key.produktID,
                            Produktnamn = g.Key.produkt,
                            Avtal = g.Sum(x => x.avtal),
                            Tillägg = g.Sum(x => x.tillagg),
                            Budget = g.Sum(x => x.tillagg + x.avtal),
                        };
            List<Intäktsbudget> budgetar = query.AsEnumerable()
            .Select(i => new Intäktsbudget
            {
                Tillägg = i.Tillägg,
                ProduktNamn = i.Produktnamn,
                Avtal = i.Avtal,
                ProdID = i.ProduktID

            }).ToList();
            return budgetar;
        }

        //Hämta alla möjliga år som är inlagda och går att välja på i prognosvyn
        public List<string> RetrieveBudgetedYears()
        {

            database = new LinqToSQLDataContext(pass);
            List<string> allocatedYears = new List<string>();
            var query = from Intäktsbudget in database.Intäktsbudgetregisters
                        where Intäktsbudget.avserÅr.Value.Year <= DateTime.Now.Year
                        group Intäktsbudget by Intäktsbudget.avserÅr into g
                        select new
                        {
                            AvserÅr = g.Key.Value.Year
                        };

            List<Intäktsbudgetregister> budgetar = query.AsEnumerable()
            .Select(i => new Intäktsbudgetregister
            {
                avtal = i.AvserÅr

            }).ToList();

            foreach (Intäktsbudgetregister iB in budgetar)
            {
                allocatedYears.Add(iB.avtal.ToString());
            }
            return allocatedYears;
        }

        //Hämtar alla tidigare gjorda prognostiseringar
        public int RetrieveBudgetedPrognosMonths(int år)
        {

            database = new LinqToSQLDataContext(pass);
            List<int> allocatedMonths = new List<int>();
            var query = (from UppföljningProgno in database.UppföljningPrognos
                         where UppföljningProgno.avserÅr.Value.Year == år
                         group UppföljningProgno by UppföljningProgno.Datum.Month into g
                         select new
                         {
                             Datum = g.Key
                         }).Count();

            int antalMån = query;


            return antalMån;
        }

        //Lägga in värden på Upparbetat av Utvecklingschef alternativt DriftChef
        public void InsertUpparbetat(string prodID, int month, int upparbetat)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                UppföljningProgno updatePrognos = database.UppföljningPrognos.Single(u => u.produktID == prodID && u.Datum.Month == month);
                {
                    updatePrognos.Upparbetat = upparbetat;
                };
                database.SubmitChanges();
                database.Connection.Close();
            }
            catch (Exception e)
            {
                database.Connection.Close();
            }

        }

        //Lägga in värden på Prognos av Marknadschef
        public void InsertPrognosValue(string prodID, int month, int prognos)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                UppföljningProgno updatePrognos = database.UppföljningPrognos.Single(u => u.produktID == prodID && u.Datum.Month == month);
                {
                    updatePrognos.prognossumma = prognos;
                };
                database.SubmitChanges();
                database.Connection.Close();
            }
            catch (Exception e)
            {
                database.Connection.Close();
            }

        }

        //public List<Intäktsbudget> GetAll()
        //{
        //    var getall = from Intäktsbudgetregister in database.Intäktsbudgetregisters
        //                 join Produkt in database.Produktregisters on Intäktsbudgetregister.produktID equals Produkt.produktID
        //                 where Intäktsbudgetregister.produktID == Produkt.produktID
        //                 select new
        //                 {
        //                     ProdID = Produkt.produktID,
        //                     ProduktNamn = Produkt.produkt
        //                 };

        //    List<Intäktsbudget> budgetar = getall.AsEnumerable()
        //    .Select(i => new Intäktsbudget
        //    {
        //        ProdID = i.ProdID,
        //        ProduktNamn = i.ProduktNamn
        //    }).ToList();

        //    return budgetar;
        //}
    }
}
